{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "def functionname(parameters):\n",
    "    function_suite\n",
    "    return expression1,\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fact(n):\n",
    "    result = 1 \n",
    "    for i in range(1,n+1):\n",
    "        result = result * i\n",
    "    return result  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6的阶乘是: 720\n"
     ]
    }
   ],
   "source": [
    "n = input(\"请输入n值\")\n",
    "print(\"%d的阶乘是:\"% int (n),fact(int(n)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0!=1         1!=1         \n",
      "2!=2         3!=6         \n",
      "4!=24        5!=120       \n",
      "6!=720       7!=5040      \n",
      "8!=40320     9!=362880    \n"
     ]
    }
   ],
   "source": [
    "for i in range(0,10):\n",
    "    result = fact(i)\n",
    "    print(\"%d!=%-10d\"%(i,result),end='')\n",
    "    if i % 2==1:\n",
    "        print()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Happy birthday to you !\n",
      "Happy birthday to you !\n",
      "Happybirthday ,daer Mike!\n",
      "Happy birthday to you !\n",
      "\n",
      "Happy birthday to you !\n",
      "Happy birthday to you !\n",
      "Happybirthday ,daer Lily!\n",
      "Happy birthday to you !\n"
     ]
    }
   ],
   "source": [
    "def happy():\n",
    "    print(\"Happy birthday to you !\")\n",
    "def happyB(name):\n",
    "    happy()\n",
    "    happy()\n",
    "    print(\"Happybirthday ,daer {}!\".format(name))\n",
    "    happy()\n",
    "\n",
    "happyB(\"Mike\")\n",
    "print()\n",
    "happyB(\"Lily\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "knock~knock~\n",
      "knock~knock~knock~knock~\n"
     ]
    }
   ],
   "source": [
    "def dup(str,times = 2):\n",
    "    print(str*times)\n",
    "dup(\"knock~\")\n",
    "dup(\"knock~\",4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def vfunc(a,*b):\n",
    "    print(type(b))\n",
    "    for n in b:\n",
    "        a+=n\n",
    "    return a\n",
    "vfunc(1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fun_example(listp,intp=0,stringp=\"A default string\"):\n",
    "    intp +=1\n",
    "    listp.append(\"A new item\")\n",
    "    return listp,intp,stringp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "fun_example.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([1, 2, 3, 'A new item'], 11, 'A default string')\n",
      "([1, 2, 3, 'A new item', 'A new item'], 11, 'A default string')\n",
      "([1, 2, 3, 'A new item', 'A new item', 'A new item'], 11, 'A default string')\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "my_int = 10\n",
    "\n",
    "print(fun_example(my_list,my_int))\n",
    "print(fun_example(my_list,my_int))\n",
    "print(fun_example(my_list,my_int))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([4, 5, 6, 'A new item'], 100, 'abcdefghijklmn')\n",
      "([4, 5, 6, 'A new item', 'A new item'], 100, 'abcdefghijklmn')\n",
      "([4, 5, 6, 'A new item', 'A new item', 'A new item'], 100, 'abcdefghijklmn')\n"
     ]
    }
   ],
   "source": [
    "my_list =[4,5,6]\n",
    "my_int = 99\n",
    "print(fun_example(listp=my_list,intp=my_int,stringp=\"abcdefghijklmn\"))\n",
    "print(fun_example(listp=my_list,intp=my_int,stringp=\"abcdefghijklmn\"))\n",
    "print(fun_example(listp=my_list,intp=my_int,stringp=\"abcdefghijklmn\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "knock~knock~\n"
     ]
    }
   ],
   "source": [
    "def func(a,b):\n",
    "    return a*b\n",
    "s = func(\"knock~\",2)\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(2, 'knock') <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def func(a,b):\n",
    "    return b,a\n",
    "s = func(\"knock\",2)\n",
    "print(s,type(s))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([1, 2, 3, 'A new item'], 11, 'A default string')\n",
      "[1, 2, 3, 'A new item', 'A new item'] \n",
      " 11 \n",
      " A default string\n"
     ]
    }
   ],
   "source": [
    "my_list = [1,2,3]\n",
    "my_int =10\n",
    "print(fun_example(my_list,my_int))\n",
    "v1,v2,v3=fun_example(my_list,my_int)\n",
    "print(v1,'\\n',v2,'\\n',v3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f= lambda x,y :x+y\n",
    "f(10,12)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'c' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[1;32mIn[24], line 6\u001b[0m\n\u001b[0;32m      4\u001b[0m     \u001b[38;5;28;01mreturn\u001b[39;00m c\n\u001b[0;32m      5\u001b[0m s\u001b[38;5;241m=\u001b[39m func(\u001b[38;5;124m\"\u001b[39m\u001b[38;5;124mknock~\u001b[39m\u001b[38;5;124m\"\u001b[39m,\u001b[38;5;241m2\u001b[39m)\n\u001b[1;32m----> 6\u001b[0m \u001b[38;5;28mprint\u001b[39m(c)\n",
      "\u001b[1;31mNameError\u001b[0m: name 'c' is not defined"
     ]
    }
   ],
   "source": [
    "n=1 \n",
    "def func(a,b):\n",
    "    c=a*b\n",
    "    return c\n",
    "s= func(\"knock~\",2)\n",
    "print(c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "knock~knock~ 1\n"
     ]
    }
   ],
   "source": [
    "n=1 \n",
    "def func(a,b):\n",
    "    n=b\n",
    "    return a*b\n",
    "s=func(\"knock~\",2)\n",
    "print(s,n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "knock~knock~ 2\n"
     ]
    }
   ],
   "source": [
    "n=1\n",
    "def func(a,b):\n",
    "    global n\n",
    "    n=b\n",
    "    return a*b\n",
    "s= func(\"knock~\",2)\n",
    "print(s,n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "knock~knock~ [2]\n"
     ]
    }
   ],
   "source": [
    "ls =[]\n",
    "def func(a,b):\n",
    "    ls.append(b)\n",
    "    return a*b\n",
    "s=func(\"knock~\",2)\n",
    "print(s,ls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ls= []\n",
    "def func(a,b):\n",
    "    ls=[]\n",
    "    ls.append(b)\n",
    "    return a*b\n",
    "\n",
    "s=func(\"knock~\",3)\n",
    "print(s,ls)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "number=5\n",
    "def func1():\n",
    "    print(number)\n",
    "func1()\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "number=5\n",
    "def func2():\n",
    "    number =3\n",
    "    print(number)\n",
    "func2()\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "number =5\n",
    "\n",
    "def func3():\n",
    "    global number\n",
    "    number =3\n",
    "    print(number)\n",
    "func3()\n",
    "print(number)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DeepLeaner:\n",
    "    learnerCount = 0\n",
    "\n",
    "    def __init__(self, name, schoolName):\n",
    "        self.name = name\n",
    "        self.schoolName = schoolName\n",
    "        DeepLeaner.learnerCount = DeepLeaner.learnerCount + 1\n",
    "\n",
    "    def getName(self):\n",
    "        return self.name\n",
    "\n",
    "    def getSchoolName(self):\n",
    "        return self.schoolName\n",
    "\n",
    "    def displayCount(self):\n",
    "        print(\"Total DeepLearner count is %d\" % DeepLeaner.learnerCount)\n",
    "\n",
    "    def displayLearner(self):\n",
    "        print(\"Name: %s, School: %s\" % (self.name, self.schoolName))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(DeepLeaner.__doc__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "newLearner1 = DeepLeaner('giggle','Zhejing University')\n",
    "newLearner2 = DeepLeaner('sherry','Zhejiang University of Technology')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(DeepLeaner.learnerCount)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total DeepLearner count is 2\n",
      "Total DeepLearner count is 2\n"
     ]
    }
   ],
   "source": [
    "newLearner1.displayCount()\n",
    "newLearner2.displayCount()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "giggle giggle\n",
      "sherry sherry\n"
     ]
    }
   ],
   "source": [
    "print(newLearner1.getName(),newLearner1.getName())\n",
    "print(newLearner2.getName(),newLearner2.getName())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Name: giggle, School: Zhejing University\n",
      "Name: sherry, School: Zhejiang University of Technology\n"
     ]
    }
   ],
   "source": [
    "newLearner1.displayLearner()\n",
    "newLearner2.displayLearner()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('test.txt','wt')as out_file:\n",
    "    out_file.write('该文本会写入到文件中\\n看到我了吧')\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "with open('test.txt','rt')as in_file:\n",
    "    text = in_file.read()\n",
    "print(text)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def except_function():\n",
    "    try:\n",
    "        # 故意除零\n",
    "        10 / 0\n",
    "    except ZeroDivisionError:\n",
    "        print(\"发生除零异常啦。\")\n",
    "    else:\n",
    "        # 正常情况\n",
    "        print(\"一切正常啦。\")\n",
    "        pass\n",
    "    finally:\n",
    "        # 无论是否发生异常都将执行最后的代码\n",
    "        print(\"finally必须被执行，不管有没有发生异常。\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "发生除零异常啦。\n",
      "finally必须被执行，不管有没有发生异常。\n"
     ]
    }
   ],
   "source": [
    "except_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1731480530.1032114\n"
     ]
    }
   ],
   "source": [
    "from time import time\n",
    "startTime=time()\n",
    "print(startTime)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "34\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "randomint = random.randint(1, 100) \n",
    "print(randomint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "94\n"
     ]
    }
   ],
   "source": [
    "randomint = random.randint(1, 100) \n",
    "print(randomint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1.         -0.97979798 -0.95959596 -0.93939394 -0.91919192 -0.8989899\n",
      " -0.87878788 -0.85858586 -0.83838384 -0.81818182 -0.7979798  -0.77777778\n",
      " -0.75757576 -0.73737374 -0.71717172 -0.6969697  -0.67676768 -0.65656566\n",
      " -0.63636364 -0.61616162 -0.5959596  -0.57575758 -0.55555556 -0.53535354\n",
      " -0.51515152 -0.49494949 -0.47474747 -0.45454545 -0.43434343 -0.41414141\n",
      " -0.39393939 -0.37373737 -0.35353535 -0.33333333 -0.31313131 -0.29292929\n",
      " -0.27272727 -0.25252525 -0.23232323 -0.21212121 -0.19191919 -0.17171717\n",
      " -0.15151515 -0.13131313 -0.11111111 -0.09090909 -0.07070707 -0.05050505\n",
      " -0.03030303 -0.01010101  0.01010101  0.03030303  0.05050505  0.07070707\n",
      "  0.09090909  0.11111111  0.13131313  0.15151515  0.17171717  0.19191919\n",
      "  0.21212121  0.23232323  0.25252525  0.27272727  0.29292929  0.31313131\n",
      "  0.33333333  0.35353535  0.37373737  0.39393939  0.41414141  0.43434343\n",
      "  0.45454545  0.47474747  0.49494949  0.51515152  0.53535354  0.55555556\n",
      "  0.57575758  0.5959596   0.61616162  0.63636364  0.65656566  0.67676768\n",
      "  0.6969697   0.71717172  0.73737374  0.75757576  0.77777778  0.7979798\n",
      "  0.81818182  0.83838384  0.85858586  0.87878788  0.8989899   0.91919192\n",
      "  0.93939394  0.95959596  0.97979798  1.        ] \n",
      " (100,)\n",
      "[-1.         -0.95959596 -0.91919192 -0.87878788 -0.83838384 -0.7979798\n",
      " -0.75757576 -0.71717172 -0.67676768 -0.63636364 -0.5959596  -0.55555556\n",
      " -0.51515152 -0.47474747 -0.43434343 -0.39393939 -0.35353535 -0.31313131\n",
      " -0.27272727 -0.23232323 -0.19191919 -0.15151515 -0.11111111 -0.07070707\n",
      " -0.03030303  0.01010101  0.05050505  0.09090909  0.13131313  0.17171717\n",
      "  0.21212121  0.25252525  0.29292929  0.33333333  0.37373737  0.41414141\n",
      "  0.45454545  0.49494949  0.53535354  0.57575758  0.61616162  0.65656566\n",
      "  0.6969697   0.73737374  0.77777778  0.81818182  0.85858586  0.8989899\n",
      "  0.93939394  0.97979798  1.02020202  1.06060606  1.1010101   1.14141414\n",
      "  1.18181818  1.22222222  1.26262626  1.3030303   1.34343434  1.38383838\n",
      "  1.42424242  1.46464646  1.50505051  1.54545455  1.58585859  1.62626263\n",
      "  1.66666667  1.70707071  1.74747475  1.78787879  1.82828283  1.86868687\n",
      "  1.90909091  1.94949495  1.98989899  2.03030303  2.07070707  2.11111111\n",
      "  2.15151515  2.19191919  2.23232323  2.27272727  2.31313131  2.35353535\n",
      "  2.39393939  2.43434343  2.47474747  2.51515152  2.55555556  2.5959596\n",
      "  2.63636364  2.67676768  2.71717172  2.75757576  2.7979798   2.83838384\n",
      "  2.87878788  2.91919192  2.95959596  3.        ] \n",
      " (100,)\n"
     ]
    }
   ],
   "source": [
    "import numpy as np  # 别名\n",
    "\n",
    "# 直接采用np生成等差数列的方法，生成100个点，每个点的取值在-1~1之间\n",
    "x_data = np.linspace(-1, 1, 100)\n",
    "\n",
    "# y = 2x + 1\n",
    "y_data = 2 * x_data + 1.0\n",
    "\n",
    "print(x_data, '\\n', x_data.shape)\n",
    "print(y_data, '\\n', y_data.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x1ebe36eb7d0>"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt \n",
    "\n",
    "\n",
    "%matplotlib inline\n",
    "\n",
    "plt.figure()\n",
    "plt.scatter(x_data, y_data) "
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "MyMLenvAllinOne",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.11.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
